/**
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you under the Apache License, Version 2.0 (the
    * "License"); you may not use this file except in compliance
    * with the License.  You may obtain a copy of the License at
    *
   * http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package storm.starter.tools;
  
  import backtype.storm.tuple.Tuple;
  import com.google.common.collect.Lists;
  import org.testng.annotations.DataProvider;
  import org.testng.annotations.Test;
  
  import java.util.ArrayList;
  import java.util.List;
  
  import static org.fest.assertions.api.Assertions.assertThat;
  import static org.mockito.Mockito.*;
  import static org.testng.Assert.assertFalse;
  import static org.testng.Assert.assertTrue;
  
  public class RankableObjectWithFieldsTest {
  
    private static final Object ANY_OBJECT = new Object();
    private static final long ANY_COUNT = 271;
    private static final String ANY_FIELD = "someAdditionalField";
    private static final int GREATER_THAN = 1;
    private static final int EQUAL_TO = 0;
    private static final int SMALLER_THAN = -1;
  
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void constructorWithNullObjectAndNoFieldsShouldThrowIAE() {
      new RankableObjectWithFields(null, ANY_COUNT);
    }
  
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void constructorWithNullObjectAndFieldsShouldThrowIAE() {
      Object someAdditionalField = new Object();
      new RankableObjectWithFields(null, ANY_COUNT, someAdditionalField);
    }
  
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void constructorWithNegativeCountAndNoFieldsShouldThrowIAE() {
      new RankableObjectWithFields(ANY_OBJECT, -1);
    }
  
    @Test(expectedExceptions = IllegalArgumentException.class)
    public void constructorWithNegativeCountAndFieldsShouldThrowIAE() {
      Object someAdditionalField = new Object();
      new RankableObjectWithFields(ANY_OBJECT, -1, someAdditionalField);
    }
  
    @Test
    public void shouldBeEqualToItself() {
      RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
      assertThat(r).isEqualTo(r);
    }
  
    @DataProvider
    public Object[][] otherClassesData() {
      return new Object[][]{ { new String("foo") }, { new Object() }, { Integer.valueOf(4) }, { Lists.newArrayList(7, 8,
          9) } };
    }
  
    @Test(dataProvider = "otherClassesData")
    public void shouldNotBeEqualToInstancesOfOtherClasses(Object notARankable) {
      RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT);
      assertFalse(r.equals(notARankable), r + " is equal to " + notARankable + " but it should not be");
    }
  
    @DataProvider
    public Object[][] falseDuplicatesData() {
      return new Object[][]{ { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1) },
          { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("Foo", 1) },
          { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("FOO", 1) },
          { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 1) },
          { new RankableObjectWithFields("", 0), new RankableObjectWithFields("", 1) }, { new RankableObjectWithFields("",
          1), new RankableObjectWithFields("bar", 1) } };
    }
  
    @Test(dataProvider = "falseDuplicatesData")
    public void shouldNotBeEqualToFalseDuplicates(RankableObjectWithFields r, RankableObjectWithFields falseDuplicate) {
      assertFalse(r.equals(falseDuplicate), r + " is equal to " + falseDuplicate + " but it should not be");
    }
  
    @Test(dataProvider = "falseDuplicatesData")
    public void shouldHaveDifferentHashCodeThanFalseDuplicates(RankableObjectWithFields r,
        RankableObjectWithFields falseDuplicate) {
     assertThat(r.hashCode()).isNotEqualTo(falseDuplicate.hashCode());
   }
 
   @DataProvider
   public Object[][] trueDuplicatesData() {
     return new Object[][]{ { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0) },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0, "someOtherField") },
         { new RankableObjectWithFields("foo", 0, "someField"), new RankableObjectWithFields("foo", 0,
             "someOtherField") } };
   }
 
   @Test(dataProvider = "trueDuplicatesData")
   public void shouldBeEqualToTrueDuplicates(RankableObjectWithFields r, RankableObjectWithFields trueDuplicate) {
     assertTrue(r.equals(trueDuplicate), r + " is not equal to " + trueDuplicate + " but it should be");
   }
 
   @Test(dataProvider = "trueDuplicatesData")
   public void shouldHaveSameHashCodeAsTrueDuplicates(RankableObjectWithFields r,
       RankableObjectWithFields trueDuplicate) {
     assertThat(r.hashCode()).isEqualTo(trueDuplicate.hashCode());
   }
 
   @DataProvider
   public Object[][] compareToData() {
     return new Object[][]{ { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("foo", 0),
         GREATER_THAN }, { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("foo", 0),
         GREATER_THAN }, { new RankableObjectWithFields("foo", 1000), new RankableObjectWithFields("bar", 0),
         GREATER_THAN }, { new RankableObjectWithFields("foo", 1), new RankableObjectWithFields("bar", 0),
         GREATER_THAN }, { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 0), EQUAL_TO },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 0), EQUAL_TO },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1000), SMALLER_THAN },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("foo", 1), SMALLER_THAN },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1), SMALLER_THAN },
         { new RankableObjectWithFields("foo", 0), new RankableObjectWithFields("bar", 1000), SMALLER_THAN }, };
   }
 
   @Test(dataProvider = "compareToData")
   public void verifyCompareTo(RankableObjectWithFields first, RankableObjectWithFields second, int expCompareToValue) {
     assertThat(first.compareTo(second)).isEqualTo(expCompareToValue);
   }
 
   @DataProvider
   public Object[][] toStringData() {
     return new Object[][]{ { new String("foo"), 0L }, { new String("BAR"), 8L } };
   }
 
   @Test(dataProvider = "toStringData")
   public void toStringShouldContainStringRepresentationsOfObjectAndCount(Object obj, long count) {
     // given
     RankableObjectWithFields r = new RankableObjectWithFields(obj, count);
 
     // when
     String strRepresentation = r.toString();
 
     // then
     assertThat(strRepresentation).contains(obj.toString()).contains("" + count);
   }
 
   @Test
   public void shouldReturnTheObject() {
     // given
     RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
 
     // when
     Object obj = r.getObject();
 
     // then
     assertThat(obj).isEqualTo(ANY_OBJECT);
   }
 
   @Test
   public void shouldReturnTheCount() {
     // given
     RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
 
     // when
     long count = r.getCount();
 
     // then
     assertThat(count).isEqualTo(ANY_COUNT);
   }
 
   @DataProvider
   public Object[][] fieldsData() {
     return new Object[][]{ { ANY_OBJECT, ANY_COUNT, new Object[]{ ANY_FIELD } },
         { "quux", 42L, new Object[]{ "one", "two", "three" } } };
   }
 
   @Test(dataProvider = "fieldsData")
   public void shouldReturnTheFields(Object obj, long count, Object[] fields) {
     // given
     RankableObjectWithFields r = new RankableObjectWithFields(obj, count, fields);
 
     // when
     List<Object> actualFields = r.getFields();
 
     // then
     assertThat(actualFields).isEqualTo(Lists.newArrayList(fields));
   }
 
   @Test(expectedExceptions = UnsupportedOperationException.class)
   public void fieldsShouldBeImmutable() {
     // given
     RankableObjectWithFields r = new RankableObjectWithFields(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
 
     // when
     List<Object> fields = r.getFields();
     // try to modify the list, which should fail
     fields.remove(0);
 
     // then (exception)
   }
 
   @Test
   public void shouldCreateRankableObjectFromTuple() {
     // given
     Tuple tuple = mock(Tuple.class);
     List<Object> tupleValues = Lists.newArrayList(ANY_OBJECT, ANY_COUNT, ANY_FIELD);
     when(tuple.getValues()).thenReturn(tupleValues);
 
     // when
     RankableObjectWithFields r = RankableObjectWithFields.from(tuple);
 
     // then
     assertThat(r.getObject()).isEqualTo(ANY_OBJECT);
     assertThat(r.getCount()).isEqualTo(ANY_COUNT);
     List<Object> fields = new ArrayList<Object>();
     fields.add(ANY_FIELD);
     assertThat(r.getFields()).isEqualTo(fields);
 
   }
 
   @DataProvider
   public Object[][] copyData() {
     return new Object[][]{ { new RankableObjectWithFields("foo", 0) }, { new RankableObjectWithFields("foo", 3,
         "someOtherField") }, { new RankableObjectWithFields("foo", 0, "someField") } };
   }
 
   // TODO: What would be a good test to ensure that RankableObjectWithFields is at least somewhat defensively copied?
   //       The contract of Rankable#copy() returns a Rankable value, not a RankableObjectWithFields.
   @Test(dataProvider = "copyData")
   public void copyShouldReturnCopy(RankableObjectWithFields original) {
     // given
 
     // when
     Rankable copy = original.copy();
 
     // then
     assertThat(copy.getObject()).isEqualTo(original.getObject());
     assertThat(copy.getCount()).isEqualTo(original.getCount());
   }
 
 }